# -*- coding:utf-8 -*-

# 使用XPath来对网页进行解析
from lxml import etree  # 导入lxml库的etree模块

text = '''
<div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a>
</ul>
</div>
'''

"""
'''
导入lxml库的etree模块,
声明一段HTML文本, 调用HTML类进行初始化,成功构造了一个XPath解析对象. 注意: HTML文本中的最后一个li节点没有闭合,但是etree模块可自动修正HTML文本.
调用tostring()方法即可输出修正后的HTML代码,结果是bytes类型.
利用decode()方法将其转成str类型.
'''
html = etree.HTML(text)
result = etree.tostring(html)
print(result.decode('utf-8'))
# 结果返回为: li节点被补全,自动添加了body,html节点.


# 读取HTML文本文件进行解析
html = etree.parse('./html/text.html',etree.HTMLParser())
RESULT = etree.tostring(html)
print(RESULT.decode('utf-8'))
# 结果是比上面多了一个DOCTYPE的声明.
"""


# 所有节点
# 用//开头的XPath规则来选取所有符合要求的节点.

"""
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//*')
print(result)
'''
使用*代表匹配所有节点,也就是整个HTML文本中的所有节点都会被获取.返回结果为列表,每个元素是Element类型,其后跟了节点的名称.所有节点都包含在列表中了.
'''


## 此处匹配可以指定节点名称, 如获取所有li节点
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//li')
print(result)
print(result[0])
'''选取所有li节点,使用//, 然后直接加上节点名称即可.调用时直接使用xpath()方法即可.'''
# 提取结果为列表,其中每个元素都是一个Element对象,要取出一个对象,可直接用中括号加索引.例如:[0]
"""


# 子节点

"""
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//li/a')
print(result)
'''通过追加/a即选择了所有li节点的所有直接a子节点,因为//li用于选中所有li节点,/a用于选中li节点的所有直接子节点a, 
二者结合在一起即获取所有li节点的所有直接a子节点. 

/用于获取直接子节点,要获取所有子孙节点,可以使用//.
'''

# 获取ul节点下的所有子孙a节点.
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//ul//a')
print(result)


# /用于获取直接子节点,在ul节点下没有直接的a子节点,只有li节点,无法获取匹配结果
html = etree.parse('./html/text.html',etree.HTMLParser())
resul = html.xpath('//ul/a')
print(resul)
"""


# 父节点
# 通过连续的/或//可以查找子节点或子孙节点.
"""
'''
首先选中href属性为link4.html的a节点,再获取其父节点,最后再获取其class属性.
'''
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//a[@href="link4.html"]/../@class')
print(result)

# 也可以通过parent:: 来获取父节点
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//a[@href="link4.html"]/parent::*/@class')
print(result)
"""



#  属性匹配
# 选取时,可用@符号进行属性过滤.
"""
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//li[@class="item-0"]')
print(result)
"""


# 文本获取
"""
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//li[@class="item-0"]/text()')
print(result)

'''
结果:只获取到了换行符,因为XPath中text()前面是/, 此处/的含义是选取直接子节点,很明显li的直接子节点都是a节点,文本都是在a节点内部的,这里匹配到的结果是被修正的li节点内部的换行符. 因为自动修正的li节点的尾标签换行了.

获取li节点内部的文本有两种方式:
1. 先选取a节点再获取文本,
2. 使用//
'''

# 1.选取到a节点再获取文本
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//li[@class="item-0"]/a/text()')
print(result)
# 返回值为2个,内容都是属性为item-0的li节点的文本.
# 逐层选取,先选取li节点,再利用/选取了其直接子节点a,再选取其文本.

# 2. 使用//选取的结果.
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//li[@class="item-0"]//text()')
print(result)
# 返回的结果是:['first item', 'fifth item', '\n'] 
# 这是选取所有子孙节点的文本,前两个是li的子节点a节点内部的文本.
# 另外一个是最后一个li节点内部的文本,即换行符.
"""





#  属性获取
# 用#符号获取节点属性
"""
html = etree.parse('./html/text.html',etree.HTMLParser())
result = html.xpath('//li/a/@href')
print(result)
'''
通过@href获取节点的href属性.
属性匹配是中括号加属性名和值来限定某个属性.如[@href="link1.html"]
而此处的@href指获取节点的某个属性.

成功获取所有li节点下a节点的href属性,以列表形式返回.
'''
"""


# 属性多值匹配
# 某些节点的某个属性可能有多个值.
"""
from lxml import etree
text = '''
<li class="li li-first"><a href="link.html">first item</a></li>
'''

html = etree.HTML(text)
result = html.xpath('//li[@class="li"]/a/text()')
print(result)
# HTML文本中li节点的class属性有两个值li和li-first,用之前的属性匹配获取,就无法匹配了.

# 用contains()函数
text = '''
<li class="li li-first"><a href="link.html">first item</a></li>
'''
html = etree.HTML(text)
result = html.xpath('//li[contains(@class,"li")]/a/text()')
print(result)
# 通过contains()方法,第一个参数传入属性名称,第二个参数传入属性值,只要此属性包含所传入的属性值,就可以完成匹配.
"""




# 多属性匹配
"""
text = '''
<li class="li li-first" name="item"><a href="link.html">first item</a></li>
'''

html = etree.HTML(text)
result = html.xpath('//li[contains(@class,"li") and @name="item"]/a/text()')
print(result)
'''
这里的li节点又增加了一个属性name,要确定这个节点,需要同时根据class和name属性来选择. 
一个条件是class属性里面包含li字符串. 另一个条件是name属性为item字符串, 二者需要同时满足,需要用and操作符相连. 相连之后置于中括号内进行条件筛选.
'''
"""



#  按序选择
# 在选择时某些属性可能同时匹配了多个节点,但是只想要其中的某个节点,可以利用中括号传入索引的方法获取特定次序的节点.
"""
text = '''
<div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a>
</ul>
</div>
'''

html = etree.HTML(text)
result = html.xpath('//li[1]/a/text()')
print(result)
result = html.xpath('//li[last()]/a/text()')
print(result)
result = html.xpath('//li[position()<3]/a/text()')
print(result)
result = html.xpath('//li[last()-2]/a/text()')
print(result)
'''
第一次选择时,选取了第一个li节点,中括号中传入数字1即可. 序号是以1开头.
第二次选择时,选取最后一个li节点,中括号中传入last()即可.
第三次选择时,选取了位置小于3的li节点,也就是位置序号为1和2的节点,得到结果为前两个li节点.
第四次选择时,选取了倒数第三个li节点,中括号中传入last()-2即可. 因为last()是最后一个,所以last()-2就是倒数第三个.
'''
"""


# 节点轴选择
# 节点轴选择方法: 子元素,兄弟元素,父元素,祖先元素
"""
text = '''
<div>
<ul>
<li class="item-0"><a href="link1.html"><span>first item</span></a><li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></ul>
</div>
'''

html = etree.HTML(text)
result = html.xpath('//li[1]/ancestor::*')
print(result)
result = html.xpath('//li[1]/ancestor::div')
print(result)
result = html.xpath('//li[1]/attribute::*')
print(result)
result = html.xpath('//li[1]/child::a[@href="link1.html"]')
print(result)
result = html.xpath('//li[1]/descendant::span')
print(result)
result = html.xpath('//li[1]/following::*[2]')
print(result)
result = html.xpath('//li[1]/following-sibling::*')
print(result)

'''
第一次选择时,调用ancestor轴,获取所有祖先节点,其后跟两个冒号,然后是节点的选择器,直接使用* 表示匹配所有节点. 返回结果是第一个li节点的所有祖先节点.
第二次选择时,加了限定条件,在冒号后面加div,得到结果只有div这个祖先节点.
第三次选择时,调用attribute轴,获取所有属性值,跟的选择器是*, 获取节点的所有属性,返回值就是li节点的所有属性值.
第四次选择时,调用child轴,获取所有直接子节点,加限定条件,选取href属性为link1.html的a节点.
第五次选择时,调用descendant轴,获取所有子孙节点,加了限定条件,获取span节点,返回结果只包含span节点,不包含a节点.
第六次选择时,调用following轴,可获取当前节点之后的所有节点,使用*匹配,加了索引选择,只获取了第二个后续节点.
第七次选择时,调用following-sibling轴,可获取当前节点之后的所有同级节点.使用*匹配,获取了所有后续同级节点.
'''
"""



#### BeautifulSoup用法

# 基本用法
"""
html = '''
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><b> The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">.....</p>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.prettify())
print(soup.title.string)
'''
先声明变量html,它是一个HTML字符串,因为body和html节点都没有闭合,接下来,将它当作第一个参数传给BeautifulSoup对象,该对象的第二个参数为解析器的类型. 此时完成了BeautifulSoup对象的初始化.然后,将这个对象赋值给soup变量.
接下来,可以调用soup的各个方法和属性解析这串HTML代码了.
首先,调用prettify()方法,这个方法可以把要解析的字符串以标准的缩进格式输出,输出结果里面包含body和html节点. BeautifulSoup可以自动更正HTML字符串格式. 是在初始化BeautifulSoup时就完成了.
然后调用soup.title.string,是输出HTML中title节点的文本内容,soup.title可以选出HTML中的title节点,再调用string属性就可以得到里面的文本了.
'''
"""


# 节点选择器
"""
html = ''' 
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom  of a well. </p>
<p class="story">...</p>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.title)
print(type(soup.title))
print(soup.title.string)
print(soup.head)
print(soup.p)

'''
首先打印输出title节点的选择结果,输出结果正是title节点加里面的文字内容. 输出它的类型,是bs4.element.Tag类型. 这是Beautiful Soup中一个重要的数据结构. 经过选择器选择后,选择结果都是这种Tag类型. Tag具有一些属性. 比如string属性,调用该属性,可以得到节点的文本内容.输出的结果刚好是节点的文本内容.
接下来,选择了head节点,结果也是节点加其内部的所有内容,
最后选择了p节点,结果是第一个p节点的内容,后面的几个p节点并没有选到.
当有多个节点时,这种选择方式只会选择到第一个匹配的节点,其他的后面节点都会忽略.
'''
# 提取信息,调用name属性得到节点名称
print(soup.title.name)

# 获取属性
# 每个节点可能有多个属性.选择这个节点元素后,可以调用attrs获取所有属性.
print(soup.p.attrs)
print(soup.p.attrs['name'])
'''
attrs的返回结果是字典形式,它把选择的节点的所有属性和属性值组合成一个字典. 如果要获取name属性,就相当于从字典中获取某个键值.只需要用中括号加属性名就可以了.
'''
print(soup.p['name'])
print(soup.p['class'])
# 注意: 有的返回结果是字符串,有的返回结果是字符串组成的列表.


# 获取内容
# 可以利用string属性获取节点元素包含的文本内容.
# 获取第一个p节点的文本:
print(soup.p.string)
# 这里选择的p节点是第一个p节点,获取的文本也是第一个p节点里面的文本.

总结:
    每一个返回结果都是bs4.element.Tag类型,它同样可以继续调用节点进行下一步的选择.
"""


# 嵌套选择
"""
html = '''
<html><head><title>The Dormouse's story</title></head>
<body>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.head.title)
print(type(soup.head.title))
print(soup.head.title.string)
'''
第一行结果是调用head之后再次调用title而选择的title节点元素.然后打印输出了它的类型. 仍然是bs4.element.Tag类型. 在Tag类型的基础上再次选择得到的依然是Tag类型,每次返回结果都相同,可以做嵌套选择了.
最后 输出它的string属性,也就是节点里的文本内容.
'''
"""


# 关联选择
# 做选择时,需要先选中某一个节点元素,然后以它为基准再选择它的子节点,父节点,兄弟节点等.子节点和子孙节点:选取节点元素之后,要是想获取它的直接子节点,可以调用contents属性.

"""
html = '''
<html>
<head>
<title>The Dormouse's story</title>
</head>
<body>
<p class="story">
    Once upon a time there were three little sisters; and their names were 
    <a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
and 
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
and they lived at the bottom of a well.
</p>
<p class="story">...</p>
'''

# from bs4 import BeautifulSoup
# soup = BeautifulSoup(html,'lxml')
# print(soup.p.contents)
# 返回结果是列表, p节点里既包含文本,又包含节点,最后会将它们以列表形式统一返回.注意: 列表中的每个元素都是p节点的直接子节点.contents属性得到的结果是直接子节点的列表.

# from bs4 import BeautifulSoup
# soup = BeautifulSoup(html,'lxml')
# print(soup.p.children)
# for i,child in enumerate(soup.p.children):
#     print(i,child)
# 调用了children属性来选择,返回结果是生成器类型.然后用for循环输出相应内容.


# 获取所有的子孙节点,调用descendants属性:
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.p.descendants)
for i,child in enumerate(soup.p.descendants):
    print(i,child)
# 返回结果是生成器,遍历输出的结果中包含了span节点.descendants会递归查询所有子节点,得到所有的子孙节点.
"""





# 父节点和祖先节点
# 获取某个节点元素的父节点,可以调用parent属性:
"""
html = '''
<html>
<head>
<title>The Dormouse's story</title>
</head>
<body>
<p class="story">
    Once upon a time there were three little sisters; and their names were 
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
</p>
<p class="story">...</p>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.a.parent)
# 选择的是第一个a节点的父节点的元素, 它的父节点是p节点,输出结果便是p节点及其内部的内容.
"""


# 获取所有的祖先节点,可调用parents属性:
"""
html = '''
<html>
<body>
<p class="story">
<a href="http://example.com/elsie' class="sister" id="link1">
<span>Elsie</span>
</a>
</p>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(type(soup.a.parents))
print(list(enumerate(soup.a.parents)))
# 返回结果是生成器类型,用列表输出了它的索引和内容,列表中的元素是a节点的祖先节点.
"""


# 兄弟节点
"""
html = '''
<html>
<body>
<p class="story">
    Once upon a time there were three were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
    Hello
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
    and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
    and they lived at the bottom of a well.
</p>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print('Next Sibling',soup.a.next_sibling)
print('Prev Sibling',soup.a.previous_sibling)
print('Next Siblings',list(enumerate(soup.a.next_siblings)))
print('Prev Siblings',list(enumerate(soup.a.previous_siblings)))
# 这里调用了4个属性,其中next_sibling和previous_sibling分别获取节点的下一个和上一个兄弟元素.next_siblings和previous_siblings则分别返回所有前面和后面的兄弟节点的生成器.
"""


# 提取信息 
"""
html = '''
<html>
<body>
<p class="story">
    Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Bob</a><a href="http://example.com/lacie"
class="sister" id="link2">Lacie</a>
</p>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print('Next Sibling:')
print(type(soup.a.next_sibling))
print(soup.a.next_sibling)
print(soup.a.next_sibling.string)
print('Parent:')
print(type(soup.a.parents))
print(list(soup.a.parents)[0])
print(list(soup.a.parents)[0].attrs['class'])
# 返回结果是单个节点,可以直接调用string,attrs等属性获得其文本和属性; 如果返回结果是多个节点的生成器,则可以转为列表后取出某个元素,然后再调用string,attrs等属性获取其对应节点的文本和属性.
"""



# 方法选择器
# find_all() 查询所有符合条件的元素
# name根据节点名来查询元素
"""
html = '''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
</div>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.find_all(name='ul'))
print(type(soup.find_all(name='ul')[0]))
# 调用find_all()方法,传入name参数,其参数值为ul. 查询所有ul节点,返回结果是列表类型.长度为2,每个元素都是bs4.element.Tag类型.
# Tag类型,可以进行嵌套查询, 查询出所有ul节点后,再继续查询其内部的li节点.
print('===================================')
for ul in soup.find_all(name='ul'):
    print(ul.find_all(name='li'))
    print(type(ul.find_all(name='li')))
# 返回结果是列表类型,列表中的每个元素还是Tag类型.
"""


# attrs 传入属性来查询
"""
html = '''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
'''
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.find_all(attrs={'id': 'list-1'}))
print(soup.find_all(attrs={'name': 'elements'}))
'''
'''
查询时传入的是attrs参数,参数类型是字典类型. 例如: 要查询id为list-1的节点,可以传入attrs={'id': 'list-1'} 的查询条件,得到结果为列表.包含内容就是符合id为list-1的所有节点.
'''
# 上面的文本,换一种方式来查询:
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.find_all(id='list-1'))
print(soup.find_all(class_='element'))
'''
传入id='list-1',查询id为list-1的节点元素.class在python中是一个关键字,后面需要加一个下划线,即class_='element',返回的结果依然是Tag组成的列表.


import re
html = '''
<div class="panel">
<div class="panel-body">
<a>Hello, this is a link</a>
<a>Hello,this is a link,too</a>
</div>
</div>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.find_all(text=re.compile('link')))
# 这里有两个a节点,其内部包含文本信息,在find_all()方法中传入text参数, 该参数为正则表达式对象,结果返回所有匹配正则表达式的节点文本组成的列表.
"""


# find()
# 返回的是单个元素,也就是第一个元素.
"""
html = '''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
</div>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.find(name='ul'))
print(type(soup.find(name='ul')))
print(soup.find(class_='list'))
# 这里的返回结果不是列表,而是第一个匹配的节点元素,类型是Tag类型.
"""







# CSS选择器
# 使用CSS选择器时,只需要调用select()方法,传入相应的CSS选择器即可.
"""
html = '''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
</div>
'''

from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.select('.panel .panel-heading'))
print(soup.select('ul li'))
print(soup.select('#list-2 .element'))
print(type(soup.select('ul')[0]))
# 用了3次CSS选择器,返回结果为符合CSS选择器的节点组成的列表. select('ul li') 是选择所有ul节点下面的所有li节点,结果便是所有的li节点组成的列表. 输出列表中元素的类型,类型为Tag类型.

# 嵌套选择
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
for ul in soup.select('ul'):
    print(ul.select('li'))
# 先选择所有ul节点,再遍历每个ul节点,选择其li节点. 输出了所有ul节点下所有li节点组成的列表.


# 获取属性
# 获取每个ul节点的id属性
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
for ul in soup.select('ul'):
    print(ul['id'])
    print(ul.attrs['id'])
# 直接传入中括号和属性名,或通过attrs属性获取属性值都可以成功.


# 获取文本
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
for li in soup.select('li'):
    print('Get Text:',li.get_text())
    print('String:',li.string)

"""




#### pyquery

from pyquery import PyQuery as pq 
# 先引入PyQuery这个对象,取别名pq

# 字符串初始化
html = '''
<div>
<ul>
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
'''
"""
doc = pq(html)
print(doc('li'))
# 先引入PyQuery这个对象,取别名pq, 声明HTML字符串,将其当作参数传递给PyQuery类,完成初始化. 将初始化的对象传入CSS选择器.



# URL初始化
# 初始化参数也可以传入网页URL
doc = pq(url='https://cuiqingcai.com')
print(doc('title'))
# PyQuery对象先请求URL,然后用得到的HTML内容完成初始化,相当于用网页源代码以字符串形式传递给PyQuery类来初始化.
# 等同于下列代码:
import requests
doc = pq(requests.get('https://cuiqingcai.com').text)
print(doc('title'))
"""


# 文件初始化.
doc = pq(filename='./html/text.html')
print(doc('li'))
# 本地文件: text.html, 内容是待解析的HTML字符串,先读取文件内容,用文件内容以字符串形式传递给PyQuery类来初始化.




